home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / (A)P / (A)P1.ADF / life / blit.c next >
C/C++ Source or Header  |  1987-05-25  |  4KB  |  143 lines
  1. /*
  2.  *   This include file includes the defines for all the blitter functions.
  3.  *   It only allows use of the `blit' operations; for area fills or line
  4.  *   drawing, it will need to be extended.
  5.  *
  6.  *   Information gleaned from the Hardware Reference Manual.
  7.  */
  8. #define BLTADD (0xdff040L)
  9. /*
  10.  *   This structure contains everything we need to know.
  11.  *   Do not do a structure copy into this!  Instead, assign
  12.  *   each field.  The last field assigned must be bltsize; that
  13.  *   starts up the blitter.  Also note that all of these are
  14.  *   write only, and you can't read them.
  15.  */
  16. struct bltstruct {
  17.    short con0 ;
  18.    short con1 ;
  19.    short afwm ;
  20.    short alwm ;
  21.    short *csource, *bsource, *asource, *dsource ;
  22.    short bltsize ;
  23.    short dmy1, dmy2, dmy3 ;
  24.    short cmod, bmod, amod, dmod ;
  25. } *blitter = BLTADD ;
  26. /*
  27.  *   We need an array which tells what to use for all 256 possible operations.
  28.  */
  29. #define USEA (0x8)
  30. #define USEB (0x4)
  31. #define USEC (0x2)
  32. #define USED (0x1)
  33. char touse[256] ;
  34. char fwma[16] ;
  35. char lwma[16] ;
  36. /*
  37.  *   Call initblitdata() once on startup before you ever call blit.
  38.  */
  39. initblitdata() {
  40.    register int i ;
  41.    register int s ;
  42.  
  43.    for (i=0; i<256; i++) {
  44.       s = USED ;
  45.       if ((i >> 4) != (i & 15))
  46.          s += USEA ;
  47.       if (((i >> 2) & 51) != (i & 51))
  48.          s += USEB ;
  49.       if (((i >> 1) & 85) != (i & 85))
  50.          s += USEC ;
  51.       touse[i] = s ;
  52.    }
  53.    s = 0xffff ;
  54.    for (i=0; i<16; i++) {
  55.       fwma[i] = s ;
  56.       s = (s >> 1) & ~0x8000 ;
  57.       lwma[i] = 0xffff - s ;
  58.    }
  59. }
  60. /*
  61.  *   This is the major user interface.  Takes addresses and offsets for
  62.  *   all four locations, a modulo and sizes, and a function.
  63.  *   Assumes the modulos for all sources and destination are the same.
  64.  *   You might want to add some arguments or delete some.
  65.  *
  66.  *   All arguments are in pixels (except the addresses and function.)
  67.  *
  68.  *   Before you call this routine, call OwnBlitter(); after you have
  69.  *   called it as many times as you need, call DisownBlitter().  Remember
  70.  *   that you cannot do any printf's or anything else which requires the
  71.  *   blitter when you own the blitter, so be careful with the debug code.
  72.  *   The machine will lock but will not crash.
  73.  */
  74. blit(aaddress, ax, ay,
  75.      baddress, bx, by,
  76.      caddress, cx, cy,
  77.      daddress, dx, dy,
  78.      modulo, xsize, ysize, function)
  79. short *aaddress, *baddress, *caddress, *daddress ;
  80. int ax, ay, bx, by, cx, cy, dx, dy, modulo,
  81.     xsize, ysize, function ;
  82. {
  83.    short *t ;
  84.  
  85. /*
  86.  *   Divide the modulo by 16 because we need words.
  87.  */
  88.    modulo >>= 4 ;
  89. /*
  90.  *   Wait for the blitter to finish whatever it needs to do.
  91.  */
  92.    WaitBlit() ;
  93. /*
  94.  *   Calculate the real addresses for d and c.
  95.  */
  96.    blitter->dsource = daddress + modulo * dy + (dx >> 4) ;
  97.    blitter->csource = caddress + modulo * cy + (cx >> 4) ;
  98. /*
  99.  *   Mask out the low order bits of dx; add these to the xsize.  (The
  100.  *   first bits will be masked using the first word mask.)
  101.  */
  102.    dx &= 15 ;
  103.    xsize += dx ;
  104.    blitter->afwm = fwma[dx] ;
  105.    blitter->alwm = lwma[(xsize - 1) & 15] ;
  106. /*
  107.  *   Now calculate the shifts for the a and b operands.  The barrel
  108.  *   shifter counts appear to be to the left instead of the more
  109.  *   intuitive to the right.  Note that I take dx into account.
  110.  */
  111.    t = aaddress + modulo * ay + (ax >> 4) ;
  112.    ax = dx - (ax & 15) ;
  113.    if (ax < 0) {
  114.       t++ ;
  115.       ax += 16 ;
  116.    }
  117.    blitter->asource = t ;
  118.    t = baddress + modulo * by + (bx >> 4) ;
  119.    bx = dx - (bx & 15) ;
  120.    if (bx < 0) {
  121.       t++ ;
  122.       bx += 16 ;
  123.    }
  124.    blitter->bsource = t ;
  125. /*
  126.  *   Now calculate the two control words.  If you want to do
  127.  *   the addresses in reverse order, set the appropriate bit in con1.
  128.  */
  129.    blitter->con0 = (ax << 12) + (touse[function] << 8) + function ;
  130.    blitter->con1 = (bx << 12) ;
  131. /*
  132.  *   Calculate the final total xsize in words, and the modulos.  The
  133.  *   modulos are in bytes when written from the 68000.
  134.  */
  135.    xsize = (xsize + 15) >> 4 ;
  136.    blitter->amod = blitter->bmod = blitter->cmod = blitter->dmod =
  137.       2 * (modulo - xsize) ;
  138. /*
  139.  *   This last assignment starts up the blitter.
  140.  */
  141.    blitter->bltsize = (ysize << 6) + xsize ;
  142. }
  143.